#include <iostream>
#include <string>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <vector>
#include <unordered_set>
#include <errno.h>


void SetNonBlock(int fd)
{
    int flags = fcntl(fd,F_GETFL,0);//显示传0表示无额外参数
    fcntl(fd,F_SETFL,flags | O_NONBLOCK);//设置非阻塞
}

int BulidConnect(int listensock)
{
    int sockfd = accept(listensock,nullptr,nullptr);//不关心客户端情况
    return sockfd;
}

bool ReadMessage(int sockfd)
{
    //非阻塞模式下,循环读取,以读取完所有内容
    std::string str;
    while(true)
    {
        char buffer[1024] = {0};
        int n = recv(sockfd,buffer,sizeof(buffer) - 1,0); 
        // std::cout << "读取到的数据大小是:" << n << std::endl;
        if(n <= sizeof(buffer) - 1 && n > 0)
        {
            //不确定数据是否读完,继续读
            buffer[n] = 0;
            str += buffer;
            continue;
        }
        else if(n == 0)
        {
            //对端连接关闭,同时接收缓冲区中也没有数据
            if(str.size())
            {
                std::cout << str << std::endl;
                std::string echo_str = "echo: " + str;
                send(sockfd,echo_str.c_str(),echo_str.size(),0);
            }
            close(sockfd);
            return false;
        }
        else
        {
            if(errno == EAGAIN || errno == EWOULDBLOCK)
            {
                //非阻塞模式下,数据读取完毕
                break;
            }
            else if(errno == EINTR)
                continue;
            else
                break;
        }
    }
    if(str.size())
    {
        std::cout << str << std::endl;
        std::string echo_str = "echo: " + str;
        send(sockfd,echo_str.c_str(),echo_str.size(),0);
    }
    return true;
}

int main()
{
    int listensock = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in addr;//服务器显示绑定地址:任意IP绑定
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    if(bind(listensock,(struct sockaddr*)&addr,sizeof(addr)) != 0)
        std::cout << "bind error" << std::endl;
    if(listen(listensock,64) != 0)
        std::cout << "listen error" << std::endl;
    SetNonBlock(listensock);
    
    //select接管哪些:listensock的accept需要接管,accept之后新分配的用于通信的fd也需要接管
    //select工作在阻塞模式下,否则非阻塞会不断返回
    
    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(listensock,&readfds);
    
    // std::vector<int> fd_queue;
    // fd_queue.push_back(listensock);
    std::unordered_set<int> fd_queue;
    fd_queue.insert(listensock);
    int max_fd  = listensock;
    while(true)
    {
        std::vector<int> fd_del;
        std::vector<int> fd_add;
        int fds = select(max_fd + 1,&readfds,nullptr,nullptr,nullptr);//异常和写不检测,写基本上总是就绪的
        if(fds > 0)
        {
            //要检测哪些fd呢？需要用户自行记录
            for(auto& e : fd_queue)
            {
                //任务派发逻辑
                
                //连接逻辑
                if(e == listensock && FD_ISSET(e,&readfds))
                {
                    int sockfd = BulidConnect(e);//传入listensock,返回相应sockfd
                    SetNonBlock(sockfd);
                    // fd_queue.insert(sockfd);//这也是不安全的行为
                    max_fd = std::max(max_fd,sockfd);
                    fd_add.push_back(sockfd);
                }
                //读逻辑
                else if(FD_ISSET(e,&readfds))
                {
                    if(!ReadMessage(e))
                    {
                        //连接关闭,fd被close的情况
                        //相应fd队列中,也应该清除对应fd
                        std::cout << "相关文件描述符: " << e << "被关闭" << std::endl;
                        // fd_queue.erase(e); 不要在循环内部直接erase,可能会导致迭代器失效
                        fd_del.push_back(e);
                    }   
                }
            }
        }
        else if(fds == 0)
        {
            std::cout << "timeout" << std::endl;
        }
        else
        {
            std::cout << "select error" << std::endl;
            break;
        }

        //在最后统一做添加
        for(auto& e : fd_add)
            fd_queue.insert(e);
        //在最后统一做清除
        for(auto& e : fd_del)
            fd_queue.erase(e);
        FD_ZERO(&readfds);
        //逻辑最后,重新初始化readfds
        for(auto& e : fd_queue)
            FD_SET(e,&readfds);
    }
    
    return 0;
}